package com.sky.service.redis.impl;

import com.sky.dto.CourierTradeQueryDto;
import com.sky.dto.PickUpDTO;
import com.sky.exception.CourierTradeOrderNotExistException;
import com.sky.exception.ParameterIsNullException;
import com.sky.mapper.redis.CourierTradeOrderMapper;
import com.sky.mapper.redis.RedisCourierMapper;
import com.sky.mapper.user.OrderDetailMapper;
import com.sky.mapper.user.OrderMapper;
import com.sky.pojo.Courier;
import com.sky.pojo.CourierTradeOrder;
import com.sky.pojo.OrderDetail;
import com.sky.pojo.Orders;
import com.sky.result.Result;
import com.sky.service.redis.CourierTradeOrderService;
import com.sky.utils.MapUtils;
import com.sky.vo.CourierTradeOrderVO;
import com.sky.vo.OrderDetailVO;
import org.springframework.beans.BeanUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
@Service
public class CourierTradeOrderServiceImpl implements CourierTradeOrderService {
    @Resource
    private CourierTradeOrderMapper courierTradeOrderMapper;
    @Resource
    private RedisCourierMapper courierMapper;
    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private OrderDetailMapper orderDetailMapper;
    @Resource
    private OrderMapper orderMapper;

    /**
     * 运单查询
     */
    @Override
    public Result queryCourierTradeOrderByCourierIdAndStatus(Long status, Long courierId) {
        //首先查询redis数据库是否有数据，有就直接返回
        //如果没有，就查询数据库，并将查询到的数据放入redis中
        //key:courier_trade_order_courierId_status存入redis中的key
        String key = "courier_trade_order_"+courierId+"_"+status;
        if(Boolean.TRUE.equals(redisTemplate.hasKey(key))){
            return Result.success(redisTemplate.opsForValue().get(key));
        }
        List<CourierTradeOrderVO> voList = new ArrayList<>();
        //1.查询数据库当前骑手的待接单信息
        List<CourierTradeOrder> list = courierTradeOrderMapper.queryCourierTradeOrderByCourierIdAndStatus(status,courierId);
        list.forEach(courierTradeOrder->{
            CourierTradeOrderVO vo = new CourierTradeOrderVO();
            BeanUtils.copyProperties(courierTradeOrder,vo);
            //2.商家和骑手的距离
            Courier courier = courierMapper.selectById(courierId);
            double courierToShopDistance = MapUtils.calculateDistance(courier.getCurLocation(), MapUtils.addressToLnglat(courierTradeOrder.getShopAddress()));
            vo.setShopAndCourierDistance(courierToShopDistance);
            //3.店铺和客户的距离
            double shopToUserDistance = MapUtils.calculateDistance(MapUtils.addressToLnglat(courierTradeOrder.getShopAddress()), MapUtils.addressToLnglat(courierTradeOrder.getCustomerAddress()));
            vo.setShopAndCustomerDistance(shopToUserDistance);
            //4.当前时间和客户期望时间的差值
            long l = Duration.between(LocalDateTime.now(), courierTradeOrder.getCustomerExpectedDeliveryTime()).get(ChronoUnit.SECONDS);
            vo.setCurrentTimeAndCustomerExpectedTime(l);
            voList.add(vo);
        });
        //排序
        AtomicInteger num = new AtomicInteger(1);
        List<CourierTradeOrderVO> res = voList.stream()
                .sorted(Comparator.comparing(CourierTradeOrderVO::getShopAndCustomerDistance))
                .map(courierTradeOrderVO -> {
                    //设置序号
                    courierTradeOrderVO.setMarkSort( num.getAndIncrement());
                    return courierTradeOrderVO;
                })
                .collect(Collectors.toList());
        //将数据放入redis中
        redisTemplate.opsForValue().set(key,res);
        return Result.success(res);
    }
    /**
     * 根据订单号查询运单信息
     */
    @Override
    public Result queryTradeOrderByTradeNo(Long tradeNo) {
        return courierMapper.queryTradeOrderByTradeNo(tradeNo);
    }
    /**
     * 查询运单菜品详情
     */
    @Override
    public List<OrderDetailVO> confirmPickUpList(Long tradeNo) {
        //判断tradeNo是否为空
        if (tradeNo == null) {
            throw new ParameterIsNullException("缺少运单号");
        }
        //查询运单
        CourierTradeOrder tradeOrder = courierTradeOrderMapper.selectByTradeNo(tradeNo);
        if(tradeOrder==null){
            throw new CourierTradeOrderNotExistException("运单不存在");
        }
        //1.查询菜品信息
        List<OrderDetail> orderDetails = orderDetailMapper.selectOrderDetailsByOrderNumber(tradeOrder.getOrderNumber());
        //2.封装结果返回
        List<OrderDetailVO> orderDetailVOS = new ArrayList<>();
        orderDetails.forEach(orderDetail -> {
            OrderDetailVO orderDetailVO = new OrderDetailVO();
            orderDetailVO.setName(orderDetail.getName());
            orderDetailVO.setNumber(orderDetail.getNumber());
            orderDetailVOS.add(orderDetailVO);
        });
        return orderDetailVOS;
    }
    /**
     * 确认取货,完成配送
     */
    @Override
    public Result confirmPickUp(PickUpDTO dto) {
        if (dto.getTradeNo() == null) {
            throw new ParameterIsNullException("运单号不能为空");
        }
        //查询运单
        CourierTradeOrder tradeOrder = courierTradeOrderMapper.selectByTradeNo(dto.getTradeNo());
        if(tradeOrder==null){
            throw new CourierTradeOrderNotExistException("运单不存在");
        }
        //判断运单状态,运单状态 1调度成功，骑手未接单  2 骑手接单，开启配送中  3.骑手确认取货，运单状态修改为
        // 5. 运单取消：顾客申请取消订单，导致运单自动取消  4 运单完成
        if (dto.getStatus()==3){
            //1.修改运单状态
            courierTradeOrderMapper.updateCourierStuatus(tradeOrder.getTradeNo(),CourierTradeOrder.DELIVORING);
            //2.修改订单状态
            orderMapper.updateStatusByNumber(tradeOrder.getOrderNumber(), Orders.TOBEDELIVERED);
            //3.删除redis缓存
            //System.out.println(tradeOrder.getCourierId());
            String key = "courier_trade_order_"+tradeOrder.getCourierId()+"_"+dto.getStatus();
            redisTemplate.delete(key);
        }else if (dto.getStatus()==4){
            //修改订单状态和订单送达时间
            orderMapper.updateStatusByNumber(tradeOrder.getOrderNumber(),Orders.COMPLETE_ORDER);
            //修改运单完成时间和运单状态
            courierTradeOrderMapper.updateCourierStuatus(tradeOrder.getTradeNo(),dto.getStatus());
            String key = "courier_trade_order_"+tradeOrder.getCourierId()+"_"+dto.getStatus();
            redisTemplate.delete(key);
        }
        return Result.success();
    }
    /**
     * 我的订单
     * */
    @Override
    public Result queryWaybillsByDate(CourierTradeQueryDto courierTradeQueryDto) {
        //查询骑手当天的订单数据 （已送达和已取消）
        List<CourierTradeOrder> courierTradeOrders =  courierTradeOrderMapper.selectCourierOrders(courierTradeQueryDto.getDate(),courierTradeQueryDto.getStatus(),courierTradeQueryDto.getCourierId());
        List<CourierTradeOrderVO> voList = new ArrayList<>();
        courierTradeOrders.forEach(tradeOrder -> {
            CourierTradeOrderVO vo = new CourierTradeOrderVO();
            BeanUtils.copyProperties(tradeOrder,vo);
            //计算商家和骑手的距离
            vo.setShopAndCourierDistance(233.00);
            //计算商家和客户的距离
            vo.setShopAndCustomerDistance(400.00);
            //计算时间差
            vo.setCurrentTimeAndCustomerExpectedTime(6555l);
            vo.setMarkSort(1);
            voList.add(vo);
        });
        return Result.success(voList);
    }
}
